Geospatially referenced building floorplan data

ABSTRACT

A server system is provided that includes a platform server system configured to store platform map data that is geospatially referenced and includes building outline data for one or more buildings, and provide the platform map data to client computer devices. The server system further includes a tenant bounded server system including one or more processors configured to store building floorplan data for a tenant entity, and provide building floorplan data to client computer devices that are authenticated for the tenant entity. The one or more processors of the tenant bounded server system are further configured to receive a set of building floorplan data for a target building included in the platform map data, determine geospatial reference data for the set of building floorplan data by aligning the set of building floorplan data with building outline data of the target building.

RELATED APPLICATION

This application is a continuation of U.S. patent application Ser. No.16/672,391, filed on Nov. 1, 2019, and entitled “GEOSPATIALLY REFERENCEDBUILDING FLOORPLAN DATA”, the entirety of which is incorporated hereinby reference.

BACKGROUND

Mapping services typically provide public map data for outdoor areas,such as streets, fields, and the outer perimeter of buildings. However,indoor floorplans for those buildings may be considered confidential tocorporate entities who typically do not make their indoor floorplansavailable to mapping services.

SUMMARY

A server system for geospatially referenced building floorplan data isprovided. The server system may include a platform server systemincluding one or more processors configured to execute a platform mapservice configured to store platform map data that is geospatiallyreferenced and includes building outline data for one or more buildings,and provide the platform map data to client computer devices. The serversystem may further include a tenant bounded server system including oneor more processors configured to store building floorplan data for atenant entity, and provide building floorplan data to client computerdevices that are authenticated for the tenant entity. The one or moreprocessors of the tenant bounded server system may be further configuredto receive a set of building floorplan data for a target buildingincluded in the platform map data. The set of building floorplan datamay be associated with the tenant entity. The one or more processors ofthe tenant bounded server system may be further configured to determinegeospatial reference data for the set of building floorplan data byaligning the set of building floorplan data with building outline dataof the target building, and store the set of building floorplan data andthe determined geospatial reference data in a tenant boundary of thetenant entity.

This Summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used to limit the scope of the claimed subject matter. Furthermore,the claimed subject matter is not limited to implementations that solveany or all disadvantages noted in any part of this disclosure.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a schematic view of an example computer system for managingboth platform map data and private tenant bounded building floorplandata according to one embodiment of the present disclosure.

FIG. 2 shows an example graphical user interface of a client mapapplication that is presenting a rendered view of platform map datamanaged by the example computer system of FIG. 1 .

FIG. 3 shows a flowchart of an example method for managing both platformmap data and private tenant bounded building floorplan data implementedby the example computer system of FIG. 1 .

FIG. 4 shows an example set of building floorplan data stored by theexample computer system of FIG. 1 .

FIG. 5 shows a flowchart of an example method for aligning a set ofbuilding floorplan data with a building outline included in platform mapdata stored by the example computer system of FIG. 1 .

FIG. 6 shows an example scaling alignment for the method of FIG. 5 .

FIG. 7A shows an example centroid used for the translation alignment forthe method of FIG. 5 .

FIG. 7B shows an example translation alignment using the determinedcentroids for the method of FIG. 5 .

FIG. 8A shows an example area difference between the set of buildingfloorplan data and the building outline data for performing rotationalignment for the method of FIG. 5 .

FIG. 8B shows an example rotation alignment by minimizing the areadifference for the method of FIG. 5 .

FIG. 9 shows an example graphical user interface for receiving alignmentinput from a user for the method of FIG. 5 .

FIG. 10 shows a flowchart of an example method for determining anchorpoints in a set of building floorplan data implemented by the examplecomputer system of FIG. 1 .

FIG. 11 shows an example set of building floorplan data and identifiedanchor points for the method of FIG. 10 .

FIG. 12 shows a flowchart of an example method for determining a mergedview of the set of building floorplan data and the platform map dataimplemented by the example computer system of FIG. 1 .

FIG. 13 shows an example merged view of the set of building floorplandata and the platform map data shown by a client computer device of theexample computer system of FIG. 1 .

FIG. 14 shows a schematic view of an example computing environment inwhich the computer system of FIG. 1 may be enacted.

DETAILED DESCRIPTION

Mapping services typically provide public map data for outdoor areas,such as streets, fields, and the outer perimeter of buildings. However,indoor floorplans for those buildings may be considered confidential tocorporate entities who typically do not make their indoor floorplansavailable to mapping services. Thus, to enable a mapping service thatmerges both outdoor and indoor maps, it is important that the storagesystem of the mapping service guarantees that the data remains withinthe tenant boundary of those corporate entities. However, displaying theindoor map in the context of an outdoor map, requires the maps to bemerged. Guarantees around privacy compliant data storage for indoor mapsmerged with outdoor maps may potentially be guaranteed by cloningseparate instances of an entire mapping technology stack required formaps (rendering, control, geocoding, autosuggest, routing) for everysingle tenant (which would be incredibly expensive). However, cloningthe entire technology stack for maps may potentially increase resourceand storage costs on the mapping service for every new entity, which maybecome prohibitively expensive as the number of entities increases.

To address these issues, FIG. 1 illustrates an example computer system10 for managing both platform map data and private tenant boundedbuilding floor plan data. The computer system 10 includes a serversystem 12, one or more client computer devices 14, and one or moretenant entity computer devices 16. The server system 12 includes aplurality of server devices that may operate in a cloud computingconfiguration. For example, the server system 12 may include a platformserver system 18 and a tenant bounded server system 20. One or moreserver devices of the server system 12 may further store map controllogic 22 that includes a mapping technology stack including functionssuch as rendering, control, geocoding, autosuggest, routing, and othermapping service functions. As will be described in more detail below,the map control logic 22 may be sent to the client computer device 14 tolocally render and display map data.

The server system 12 may further be configured to handle authenticationfor the one or more client computer devices 14 and tenant entitycomputer devices 16 as belonging to a tenant entity or otherwise beingauthorized to have access to data of the tenant entity stored on thetenant bounded server system 20. As used herein, the term “tenant”refers to an entity, such as a person or organization, that occupies orotherwise controls an area of a building, structure, etc. For example, atenant entity may be the entity that leases, owns, or occupies a spacein a building indicated by a set of building floor plan data. Further,as used herein, the terms “tenant boundary” and “tenant bounded” mayrefer to server devices or data that requires authorization by a tenantentity to access. That is, users and devices that are authenticated asbelonging to the tenant entity or otherwise authorized by the tenantentity may access the tenant bounded server system 20 and/or data storedby the tenant bounded server system 20. It should be appreciated thatthe tenant bounded server system 20 may include separate tenantboundaries for separate tenant entities, and may implement a suitabledata privacy standards and protocols.

As illustrated in FIG. 1 , the platform server system 18 includes one ormore processors 23, storage devices 24, and other suitable computercomponents. In one example, the platform server system 18 may include aplurality of server devices configured to operate in a cloud computingconfiguration to perform that functions of the platform server system 18described herein. The one or more processors 23 of the platform serversystem 18 are configured to execute a platform map service 26 configuredto store platform map data 28, and provide the platform map data 28 toclient computer devices 14.

The client computer devices 14 each include a processor 30, an inputdevice 32 such as a capacitive touch screen, keyboard and mouse, etc., adisplay 34, and other suitable computer components such as volatile andnon-volatile storage devices. The processor 30 of an example clientcomputer device 14 is configured execute a client map program 36configured to handle client-side user input received via the inputdevice 32, such as map navigation and zoom inputs, and display renderedmap data 38 via the display 34. As discussed above, the server system 12may send the map control logic 22 to the client computer device 14 inresponse to a user triggering a map experience. The map control logic 22may be locally executed as client-side map control logic 40 within theclient map program 36. In this manner, the client-side map control logic40 may be configured to perform the functions of the map control logic22, such as rendering, control, geocoding, autosuggest, routing, andother mapping service functions. It should be appreciated that theclient map program 36 may take any suitable form, such as, for example,code executed within a browser, an application program executed on theclient computer device 14, etc. As a specific example, the map controllogic 22 may be sent to the client computer device 14 in the form of amodified JavaScript Object Notation program, and may further includerelevant portions of the platform map data 28 for the user of the clientcomputer device 14. The map control logic 22 may be executed as theclient-side map control logic 40 within the client map program 36 whichmay take the form of a browser program, or an application being executedwithin a browser program.

FIG. 2 illustrates an example graphical user interface (GUI) 42 of theclient map program 36 being presented via the display 34 of the clientcomputer device 14. The GUI 42 may include a view of the rendered mapdata 38. The rendered map data 38 may be rendered by the client-side mapcontrol logic 40 executed by the client computer device 14. The GUI 42may also include navigation controls such as, for example, a zoomcontrol 44 that receives a user zoom input. It should be appreciatedthat the GUI 42 may include other types of navigation controls.Additionally, it should be appreciated that the GUI 42 of the client mapprogram 36 may receive user input via other input modalities. Forexample, a user may enter a zoom input via a pinching or spreadinggesture input to a capacitive touch screen input device. As anotherexample, a user may enter a navigation input via a finger drag gestureinput. In a desktop computer example, the user may enter input via aclick-and-drag input of a mouse, or by pressing arrow keys on akeyboard. It should be appreciated that the client map program 36 is notlimited to the input modalities and techniques described above, and mayreceive user inputs via any suitable method.

Turning back to FIG. 1 , the platform server system 18 is configured tostore platform map data 28 that is geospatially referenced. That is, theplatform map data 28 may include geospatial reference data 46 forobjects in the platform map data 28 that may be used by the map controllogic 22 and the corresponding client-side map control logic 40 forgeopositioning and rendering map data. In one example, the geospatialreference data 46 may include latitude and longitude values for objectsand/or references positions or locations in the platform map data 28.The platform map data 28 may further include building outline data 48for one or more buildings 50. Example renderings of building outlinedata 48 for one or more buildings 50 are shown in FIG. 2 . The buildingoutline data 48 may include a polygon indicating a perimeter orfootprint of each building. The platform map data 28 may further includegeospatial reference data 46 for each building outline in the buildingoutline data 48.

When a user of a client computer device 14 triggers an experience forthe mapping service, the client map program 36 may call/communicate withthe server system 12, and receive map control logic 22 to be executed asclient-side map control logic 40 within the client map program 36. Forexample, the user may trigger a mapping service experience by opening amapping application on the client computer device, interacting with anelectronic meeting invitation that includes directions to the meeting,or another type of user interaction that triggers the mapping service.After triggering the mapping service, the client map program 36 may sendan address or coordinates for a location to be displayed to the serversystem 12. As discussed above, the server system 12 may send the mapcontrol logic 22 and the relevant platform map device 28 to the clientcomputer device 14 to cause the client computer device 14 to execute themap control logic 22 as client-side map control logic 40. The client mapprogram 36 may further communicate client-side user inputs to theclient-side map control logic 40, such as, for example, navigationinputs, zoom inputs, etc. In some examples, the client-side map controllogic 40 may render tiles or areas of the platform map data 28, and theclient map program 36 may handle navigation inputs and zoom inputswithin the context of the rendered tile or area locally on the clientcomputer device 14.

In one example, the user of the client computer device 14 may trigger anexperience for an indoor map for a building that includes buildingfloorplan data. However, as discussed above, building floorplan data maybe private and stored within a tenant boundary of the entity that ownsthe building floorplan data. That is, the indoor floorplan data for abuilding may be confidential to a tenant entity, such as, for example, acorporate entity. When storing this data, the server system 12 mayadhere to relevant privacy regulations and protocols to guarantee thatthe data remains within a tenant boundary of that tenant entity.However, to display the indoor floorplan data of a building in thecontext of an outdoor map that is stored separately from the indoorfloorplan data, the two sets of data need to be merged while stilladhering the privacy protocols. However, cloning separate instances ofthe entire mapping technology stack maps (e.g. rendering, control,geocoding, autosuggest, routing) implemented by the map control logic 22for each separate tenant entity may potentially increase resource andstorage consumptions, which may become resource expensive as the numberof tenant entities increases.

To address these issues, the server system 12 implements a method ofgeospatially referencing building floorplan data inside of a workflow inthe tenant boundaries and storing the geospatially referenced buildingfloorplan data within those tenant boundaries. As illustrated in FIG. 1, the server system 12 includes a tenant bounded server system 20. Thetenant bounded server system 20 may include one or more server devices,each server device including one or more processors 52, one or morestorage devices 54, and other suitable computer components. In oneexample, each tenant entity may be assigned respective server devicesthat are bound to that tenant entity such that data stored on thatserver device is accessible only by authorized users associated with thetenant entity.

The server system 12 may include authorization protocols to determinewhether a client computer device 14 is authorized to access data storedon a server device of the tenant bounded server system 20. For example,the server system 12 may include enterprise accounts that are associatedwith one or more server devices of the tenant bounded server system 20.In this example, users that are logged into accounts associated withthat enterprise may be authorized to access data the associated serverdevice. As another example, the server system 12 may implementauthorization protocols such as OAuth 2.0, and may determine whether auser of a client computer device 14 is authorized to access data storedon the tenant bounded server system 20 based on an authorization tokenreceived from the client computer device 14. It should be appreciatedthat the server system 12 may implement other types of authorizationtechniques and protocols not specifically described above to determinewhether particular users and/or client computer devices are authorizedby a tenant entity to access data stored with a tenant boundary of thattenant entity.

The tenant bounded server system 20 may be configured to store buildingfloorplan data 56 for a tenant entity, and provide the buildingfloorplan data 56 to client computer devices 14 that are authenticatedfor the tenant entity, or are otherwise authorized by the tenant entityto access the building floorplan data 56. As illustrated in FIG. 1 , thebuilding floorplan data 56 may initially be uploaded to the serversystem 12 by a tenant entity computer device 16 that is associated witha particular tenant entity. Typically, the building floorplan data 56 isnot geospatially referenced within the context of an outdoor map. Thus,the tenant bounded server system 20 may be configured to executegeospatial referencing logic 58 that implements a method illustrated anddescribed with reference to FIGS. 3-9 to perform geospatial referencingof the building floorplan data 56.

FIG. 3 shows a flowchart for a computer-implemented method 300 ofgeospatially referencing a set of building floorplan data 56. At step300, the method 300 may include receiving a set of building floorplandata 56 for a target building 50A included in the platform map data 28,the set of building floorplan data 56 being associated with the tenantentity. At 304, the method 300 may include determining geospatialreference data 60 for the set of building floorplan data 56 by aligningthe set of building floorplan data 56 with building outline data 48 ofthe target building 50A. At 306, the method 300 may include storing theset of building floorplan data 56 and the determined geospatialreference data 60 in a tenant boundary of the tenant entity. At 308, themethod 300 may include providing the set of building floorplan data 56and the determined geospatial reference data 60 to an authorized clientcomputer device 308.

FIG. 4 illustrates an example set of building floorplan data 56 for atarget building 50A shown in FIG. 2 . The example set of buildingfloorplan data 56 may be received by the tenant bounded server system 20at step 302 of method 300. In one example, step 302 may further includean identification of the target building 50A associated with theuploaded set of floorplan data. For example, the identification mayinclude an address, geospatial coordinates, or another type ofidentification of the target building 50A. As discussed above, typicallythe building floorplan data 56 when initially uploaded to the serversystem 12 may not be geospatially referenced in the context of anoutdoor map. Thus, a server device associated with tenant entity of thetenant bounded server system 20 may be configured to perform step 304 ofthe method 300 to determine geospatial reference data 60 for the set ofbuilding floorplan data 56 by aligning the set of building floorplandata 56 with building outline data 48 of the target building 50A. Itshould be appreciated that the workflow logic for step 304 is performedwithin the tenant boundary, and is thus not exposed to the publicuserbase of the server system 12. The set of floorplan data 56 andassociated geospatial reference data 60 may then be stored on storagedevices 54 of the tenant bounded server system 20 within the tenantboundary of the associated tenant entity that owns that set of floorplandata 56. Then, using the authorization techniques and protocolsdescribed herein, that set of building floorplan data 56 and geospatialreference data 60 may be accessible by authorized users and/or clientcomputer devices 14 such that the set of building floorplan data 56 maybe rendered and displayed in the context of the outdoor map from theplatform map data 28.

In one example, to align the set of building floorplan data 56 withbuilding outline data 48 of the target building 50A at step 304, thetenant bounded server system 20 may implement a computer-implementedmethod 500 shown in FIG. 5 . At step 502, the method 500 may include ascaling alignment step. At step 504, the method 500 may include atranslation alignment step. At step 506, the method 500 may include arotation alignment step. At 508, the method 500 may include a user inputalignment step. Each step 502-508 may include the sub-steps shown in theflowchart of FIG. 5 .

Step 502 may include sub-steps 502A and 502B. At step 502A, the method500 may include determining a perimeter ratio between a perimeter of thebuilding outline data 48 of the target building 50A and a perimeter ofthe set of building floorplan data 56. At step 502B, the method 500 mayinclude scaling the set of building floorplan data based on theperimeter ratio.

FIG. 6 illustrates an example of scaling a set of building floorplandata 56. As shown, the tenant bounded server system 20 may be configuredto, within the tenant boundary, to determine a perimeter 62 of a polygonrepresenting the building outline of the target building 50A based onthe building outline data 48. Next, the tenant bounded server system 20may be further configured to determine a perimeter 64 of a polygonrepresenting the outline of the set of building floorplan data 56. Thetenant bounded server system 20 may then determine a perimeter ratiobetween the perimeter 62 of the building outline data 48 of the targetbuilding 50A and a perimeter 64 of the set of building floorplan data56. Using the determined perimeter ratio, the tenant bounded serversystem 20 may be configured to scale the set of building floorplan data48 such that the set of building floorplan data 56 has a substantiallyequal value for the perimeter as the building outline data 48 of thetarget building 50A.

Step 504 may include sub-steps 504A and 504B. At step 504A, the method500 may include determining a centroid of the building outline data 48of the target building 50A and a centroid of the set of buildingfloorplan data 56. At step 504B, the method 500 may include translatingthe set of building floorplan data 56 to align the centroid of thebuilding outline data 48 of the target building 50A with the centroid ofthe set of building floorplan data 56.

FIGS. 7A and 7B illustrate an example of translating a set of buildingfloorplan data 56. As shown, the tenant bounded server system 20 may beconfigured to determine a centroid 66 of a polygon representing thebuilding outline data 48 for the target building 50A. The tenant boundedserver system 20 may further determine a centroid 68 of a polygonrepresenting an outside perimeter of the set of building floorplan data56. These centroids may be determined via any suitable technique. Asshown in FIG. 7B, after determining the centroids 66 and 68, the tenantbounded server system 20 may be configured to translate the set ofbuilding floorplan data 56 to align the two centroids 66 and 68 tooverlap each other.

Step 506 may include sub-step 506A. At 506A, the method 500 may includerotating the set of building floorplan data 56 to minimize a differencein an area between the set of building floorplan data 56 and thebuilding outline data 48 of the target building 50A.

FIGS. 8A and 8B illustrate an example of rotating a set of buildingfloorplan data 56. As shown, the tenant bounded server system 20 may beconfigured to compare an area of a polygon representing the buildingoutline data 48 of the target building 50A to a polygon representing anoutside perimeter of the set of building floorplan data 56. FIG. 8Aillustrates a difference 70 (shown as shaded regions) in the areabetween the set of building floorplan data 56 and the building outlinedata 48 of the target building 50A based on an initial orientation ofthe set of building floorplan data 56. The tenant bounded server system20 may be configured to rotate the orientation of the set of buildingfloorplan data 56 about the centroid 68 to minimize the difference 70 inarea. FIG. 8B shows an example result of this rotation alignment.

In one example, after programmatically performing steps 502-506, the setof building floorplan data 56 may potentially be misaligned with thebuilding outline data 48 of the target building 50A. This misalignmentmay occur due to several different reasons. For example, the buildingoutline data 48 for the target building 50A of the platform map data 28may be simplified or potentially erroneous, and thus may not match thecorresponding set of building floorplan data 56 which typically may bemore detailed and accurate. As another example, the tenant entityassociated with the building floorplan data 56 may only occupy a portionof a floor in the target building 50A. Thus, the building floorplan data56 may only include data for a portion of a floor, and thus a perimeterof that building floorplan data 56 may not match an outside perimeter ofthe building. In these scenarios, aligning the set of building floorplandata 56 with the building outline data 48 of the target building maypotentially be incorrect.

To address this issue, the tenant bounded server system 20 implementingmethod 500 may be further configured to implement step 508 of the method500. Step 508 may include sub-steps 508A and 508B. At 508A, the method500 may include receiving an alignment input 72 from an authorized userof the tenant entity. At step 508B, the method 500 may include aligningthe set of building floorplan data 56 with the building outline data 48of the target building 50A based on the alignment input 72.

As illustrated in FIG. 1 , the server system 12 may include a tenantaccess front-end 74 executed by one or more server devices of the serversystem 12, such as, for example, one or more server devices of thetenant bounded server system 20. The tenant access front-end 74 mayprovide a GUI via which a user of the tenant entity computer device 16may be authenticated. For example, the user of the tenant entitycomputer device 16 may log-into an enterprise account for the associatedtenant entity, or may otherwise be authenticated by tenant accessfront-end 74. In one example, the set of building floorplan data 56 maybe uploaded via the tenant access-front end 74.

As shown in FIG. 1 , the user authorized user of the tenant entitycomputer device 16 may send an alignment inputs 72 to the tenant accessfront-end 74. For example, the tenant access front-end 74 may include aGUI via which the user of the tenant entity computer device 16 mayinteract with the set of building floorplan data 56 to manually alignthe set of building floorplan data 56 with the building outline data 48of the target building 50A.

FIG. 9 shows an example GUI for the tenant access front-end 74 beingdisplayed via a display of the tenant entity computer device 16. Asshown, the GUI may include several tools include a move tool, a rotatetool, a resize tool, and an anchor tool. The move tool is currentselected by the user, and may be used to manually perform a translationalignment. Further in this example, the resize tool may be used tomanually perform a scaling alignment, and the rotate tool may be used tomanually perform a rotation alignment. The anchor tool may be used toidentify anchor points between a plurality of floors in a set ofmultiple floor plans, which will be described in more detail below.Using these tools of the GUI, the authorized user may enter alignmentinputs 72 to the GUI of the tenant access front-end 74. The tenantbounded server system 20 may then align the set of building floorplandata 56 further based on these alignment inputs 72 received from theauthorized user of the tenant entity computer device 16.

In one example, the set of building floorplan data 56 may includebuilding floorplan data for a plurality of floors. That is, the tenantentity may occupy multiple floors in a building, and may uploadedbuilding floorplan data 56 for each of those floors. In one example, thetenant bounded server system 20 may separately align floorplan data foreach of the floors to the building outline data 48 of the targetbuilding 50A. In another example, the tenant bounded server system 20may be configured to determine a join between the building floorplandata 56 for each floor. To determine the join of the set, the tenantbounded server system 20 may be configured to implement the method 1000shown in FIG. 10 . In one example, the method 1000 may be performed bythe method 500, and the entire joined set of the building floorplan data56 may be aligned according to the method 500.

Method 1000 may include steps 1002-1006. At 1002, the method 1000 mayinclude determining anchor points between the building floorplan data ofthe plurality of floors. At 1004, the method 1000 may include joiningthe set of building floorplan data of the plurality of floors based onthe determined anchor points. At 1006, the method 1000 may includealigning the joined set of building floorplan data with the buildingoutline data of the target building.

FIG. 11 shows an example of building floorplan data 56A and 56B for twodifferent floors in a building occupied by a tenant entity. As shown,the first building floorplan data 56A for a first floor is differentfrom the second building floorplan data 56B for a second floor. To alignthe first and second building floorplan data 56A and 56B relative toeach other, the tenant bounded server system 20 may be configured todetermine one or more anchor points 80. The anchor points 80 may, forexample, be objects that travel vertically through the building, and maythus be used to align the building floorplan data on top of each other.For example, the anchor points 80 may be determined based on identifyingelevators or stairs in the set of building floor plan data 56, aselevators and stairs typically extend vertically in a building througheach floor. However, it should be appreciated that other types of anchorpoints may be identified, such as, for example, a support pillar thatextends vertically through the building, a fire escape ladder, etc.

In one example, the anchor points 80 may be determined by identifyingsymbols or words in the building floorplan data 56 that indicate anelevator, stairs, or other type of anchor point. In the exampleillustrated in FIG. 11 , the anchor points 80 may be determined based onprogrammatically identifying the symbols used for the elevator and thestairs. In this example, the tenant bounded server system 20 may beconfigured to perform visual processing on the building floorplan data56 to identify these symbols. In another example, the building floorplandata 56 may include text that identifies different objects in thefloorplan. Accordingly, the tenant bounded server system 20 may beconfigured to perform text processing on the building floorplan data 56to identify the terms “elevator”, “stairs”, or other objects being usedas anchor points. In yet another example, the anchor points may bemanually identified by an authorized user via the GUI of the tenantaccess front-end 74 shown in FIG. 9 using the anchor tool. For example,the authorized user may manually select an anchor point in the floorplandata for each floor.

After determining the anchor points 80, each of the building floorplandata 56A and 56B in the set may be joined by those anchor points. Thejoined set of building floorplan data 56 may then be used together to bealigned with the building outline data of the target building accordingto the techniques described with reference to FIG. 5 .

After the set of building floorplan data 56 has been aligned to thebuilding outline data 48 of the target building 50A, the tenant boundedserver system 20 may be configured to determine geospatial referencedata 60 for the set of building floorplan data 56. For example, thegeospatial reference data 60 for the set of building floorplan data 56may be determined relative to the already known geospatial referencedata 46 for the building outline data 48 of the target building 50Astored by the platform map data 28. The set of building floorplan data56 and the geospatial reference data 60 for the floorplan data may thenbe stored on the tenant bounded server system 20. It should beappreciated the methods and techniques for aligning the set of buildingfloorplan data 56 and determining geospatial reference data 60 isperformed within the tenant boundary of the associated tenant entity onthe tenant bounded server system 20. Thus, the tenant entity's privatedata is not exposed to other devices on the server system 12.

In response to a mapping request from a client device that is authorizedfor the tenant entity, the geospatially referenced building floorplandata 78 may be sent to the client computer device 14 that has beenauthorized to view that data. Additionally, the map control logic 22 andthe relevant portions of the platform map data 28 are also sent to theclient computer device 14. The server system 12 may implement the method1200 shown in FIG. 12 to cause the client computer device 14 to presenta merged view of the indoor and outdoor map data.

Method 1200 may include steps 1202 and 1204. At 1202, the method 1200may include determining that a client computer device is authorized toaccess the set of building floor plan data stored on tenant boundedserver system. In the example illustrated in FIG. 1 , the clientcomputer device 14 may be configured to send an authorization token 76to the server system 12. However, it should be appreciated that theclient computer device 14 may be authorized using other techniques, suchas, for example, a log-in to an enterprise account of the tenant entityon the server system 12.

When a user of the client computer device 14 triggers an experiencewhere the set of building floorplan data may be shown, the clientcomputer device 14 may send a request to the server system 12, which isconfigured to send the map control logic 22 and at least a portion ofthe platform map data 28 to the client computer device 14, which may beconfigured to execute the received map control logic 22 as theclient-side map control logic 40 to present rendered map data 38 via adisplay 34 of the client computer device 14. During this process, thegeospatially referenced building floorplan data 78 may also be retrievedfrom the tenant bounded server system 20, contingent on the clientcomputer device 14 being authorized to access that data.

After retrieving the geospatially referenced building floorplan data 78,the method 1200 may further include step 1204, and may include sendingthe set of building floor plan data 78 and at least a portion of theplatform map data 28 to the client computer device 14 to cause theclient computer device 14 to present a merged view of the set ofbuilding floorplan data 56 and the portion of platform map data 28. FIG.13 illustrates an example merged view 82 of the set of buildingfloorplan data 56 and the platform map data 28. As shown, the set ofbuilding floorplan data 56 is displayed in the context of the outdoormap from the platform map data.

According to the techniques and methods described above, buildingfloorplan data may be geospatially referenced inside the workflow in thetenant boundaries specified by a tenant entity that controls the data.Further, that data may be stored within those tenant boundaries, andmerged with outdoor map data stored on a mapping platform for users thatare authorized by that tenant entity to view the data. Additionally, themerged view of the map data may be generated without requiring theentire mapping technology stack (e.g. rendering, control, geocoding,autosuggest, routing) to be duplicated for each tenant, whilenonetheless providing guarantees around privacy compliant data storagefor the building floorplan data of each tenant entity.

Additionally, it should be appreciated that while the above disclosureis described with reference to one tenant entity, the server system 12may be configured to store data for multiple different tenant entities.That is, a plurality of sets of building floorplan data 56 may be storedfor a plurality of different tenant entities having separate tenantboundaries. Further, in one example, a single user may be authorized formore than one tenant entity, and may access the building floorplan data56 for multiple tenant entities. In this example, the server system 12may be configured to determine a plurality of tenant entities that auser of the client computer device 14 is authorized for, and mayretrieve building floorplan data 56 for each of those plurality oftenant entities. The client-side map control logic 40 and client mapprogram 36 may then be configured to generate a merged view thatincludes each of the building floorplan data 56 from the plurality oftenant entities and the outdoor map data of the platform map data 28.

In some embodiments, the methods and processes described herein may betied to a computing system of one or more computing devices. Inparticular, such methods and processes may be implemented as acomputer-application program or service, an application-programminginterface (API), a library, and/or other computer-program product.

FIG. 14 schematically shows a non-limiting embodiment of a computingsystem 1400 that can enact one or more of the methods and processesdescribed above. Computing system 1400 is shown in simplified form.Computing system 1400 may embody one or more client computer devices 14,tenant computer devices 16, and one or more server devices of the serversystem 12 described above and illustrated in FIG. 1 . Computing system1400 may take the form of one or more personal computers, servercomputers, tablet computers, home-entertainment computers, networkcomputing devices, gaming devices, mobile computing devices, mobilecommunication devices (e.g., smart phone), and/or other computingdevices, and wearable computing devices such as smart wristwatches andhead mounted augmented reality devices.

Computing system 1400 includes a logic processor 1402 volatile memory1404, and a non-volatile storage device 1406. Computing system 1400 mayoptionally include a display subsystem 1408, input subsystem 1410,communication subsystem 1412, and/or other components not shown in FIG.14 .

Logic processor 1402 includes one or more physical devices configured toexecute instructions. For example, the logic processor may be configuredto execute instructions that are part of one or more applications,programs, routines, libraries, objects, components, data structures, orother logical constructs. Such instructions may be implemented toperform a task, implement a data type, transform the state of one ormore components, achieve a technical effect, or otherwise arrive at adesired result.

The logic processor may include one or more physical processors(hardware) configured to execute software instructions. Additionally oralternatively, the logic processor may include one or more hardwarelogic circuits or firmware devices configured to executehardware-implemented logic or firmware instructions. Processors of thelogic processor 1402 may be single-core or multi-core, and theinstructions executed thereon may be configured for sequential,parallel, and/or distributed processing. Individual components of thelogic processor optionally may be distributed among two or more separatedevices, which may be remotely located and/or configured for coordinatedprocessing. Aspects of the logic processor may be virtualized andexecuted by remotely accessible, networked computing devices configuredin a cloud-computing configuration. In such a case, these virtualizedaspects are run on different physical logic processors of variousdifferent machines, it will be understood.

Non-volatile storage device 1406 includes one or more physical devicesconfigured to hold instructions executable by the logic processors toimplement the methods and processes described herein. When such methodsand processes are implemented, the state of non-volatile storage device1406 may be transformed—e.g., to hold different data.

Non-volatile storage device 1406 may include physical devices that areremovable and/or built-in. Non-volatile storage device 1406 may includeoptical memory (e.g., CD, DVD, HD-DVD, Blu-Ray Disc, etc.),semiconductor memory (e.g., ROM, EPROM, EEPROM, FLASH memory, etc.),and/or magnetic memory (e.g., hard-disk drive, floppy-disk drive, tapedrive, MRAM, etc.), or other mass storage device technology.Non-volatile storage device 1406 may include nonvolatile, dynamic,static, read/write, read-only, sequential-access, location-addressable,file-addressable, and/or content-addressable devices. It will beappreciated that non-volatile storage device 1406 is configured to holdinstructions even when power is cut to the non-volatile storage device1406.

Volatile memory 1404 may include physical devices that include randomaccess memory. Volatile memory 1404 is typically utilized by logicprocessor 1402 to temporarily store information during processing ofsoftware instructions. It will be appreciated that volatile memory 1404typically does not continue to store instructions when power is cut tothe volatile memory 1404.

Aspects of logic processor 1402, volatile memory 1404, and non-volatilestorage device 1406 may be integrated together into one or morehardware-logic components. Such hardware-logic components may includefield-programmable gate arrays (FPGAs), program- andapplication-specific integrated circuits (PASIC/ASICs), program- andapplication-specific standard products (PSSP/ASSPs), system-on-a-chip(SOC), and complex programmable logic devices (CPLDs), for example.

The terms “module,” “program,” and “engine” may be used to describe anaspect of computing system 1400 typically implemented in software by aprocessor to perform a particular function using portions of volatilememory, which function involves transformative processing that speciallyconfigures the processor to perform the function. Thus, a module,program, or engine may be instantiated via logic processor 1402executing instructions held by non-volatile storage device 1406, usingportions of volatile memory 1404. It will be understood that differentmodules, programs, and/or engines may be instantiated from the sameapplication, service, code block, object, library, routine, API,function, etc. Likewise, the same module, program, and/or engine may beinstantiated by different applications, services, code blocks, objects,routines, APIs, functions, etc. The terms “module,” “program,” and“engine” may encompass individual or groups of executable files, datafiles, libraries, drivers, scripts, database records, etc.

When included, display subsystem 1408 may be used to present a visualrepresentation of data held by non-volatile storage device 1406. Thevisual representation may take the form of a graphical user interface(GUI). As the herein described methods and processes change the dataheld by the non-volatile storage device, and thus transform the state ofthe non-volatile storage device, the state of display subsystem 1408 maylikewise be transformed to visually represent changes in the underlyingdata. Display subsystem 1408 may include one or more display devicesutilizing virtually any type of technology. Such display devices may becombined with logic processor 1402, volatile memory 1404, and/ornon-volatile storage device 1406 in a shared enclosure, or such displaydevices may be peripheral display devices.

When included, input subsystem 1410 may comprise or interface with oneor more user-input devices such as a keyboard, mouse, touch screen, orgame controller. In some embodiments, the input subsystem may compriseor interface with selected natural user input (NUI) componentry. Suchcomponentry may be integrated or peripheral, and the transduction and/orprocessing of input actions may be handled on- or off-board. Example NUIcomponentry may include a microphone for speech and/or voicerecognition; an infrared, color, stereoscopic, and/or depth camera formachine vision and/or gesture recognition; a head tracker, eye tracker,accelerometer, and/or gyroscope for motion detection and/or intentrecognition; as well as electric-field sensing componentry for assessingbrain activity; and/or any other suitable sensor.

When included, communication subsystem 1412 may be configured tocommunicatively couple various computing devices described herein witheach other, and with other devices. Communication subsystem 1412 mayinclude wired and/or wireless communication devices compatible with oneor more different communication protocols. As non-limiting examples, thecommunication subsystem may be configured for communication via awireless telephone network, or a wired or wireless local- or wide-areanetwork, such as a HDMI over Wi-Fi connection. In some embodiments, thecommunication subsystem may allow computing system 1400 to send and/orreceive messages to and/or from other devices via a network such as theInternet.

The following paragraphs provide additional support for the claims ofthe subject application. One aspect provides a server system comprisinga platform server system including one or more processors configured toexecute a platform map service configured to store platform map datathat is geospatially referenced and includes building outline data forone or more buildings, and provide the platform map data to clientcomputer devices. The server system further comprises a tenant boundedserver system including one or more processors configured to storebuilding floorplan data for a tenant entity, and provide buildingfloorplan data to client computer devices that are authenticated for thetenant entity. The one or more processors of the tenant bounded serversystem are further configured to receive a set of building floorplandata for a target building included in the platform map data. The set ofbuilding floorplan data is associated with the tenant entity. The one ormore processors of the tenant bounded server system are furtherconfigured to determine geospatial reference data for the set ofbuilding floorplan data by aligning the set of building floorplan datawith building outline data of the target building, and store the set ofbuilding floorplan data and the determined geospatial reference data ina tenant boundary of the tenant entity. In this aspect, additionally oralternatively, to align the set of building floorplan data with thebuilding outline data of the target building, the one or more processorsof the tenant bounded server system may be further configured todetermine a centroid of the building outline data of the target buildingand a centroid of the set of building floorplan data, and translate theset of building floorplan data to align the centroid of the set ofbuilding floorplan data with the centroid of the building outline dataof the target building. In this aspect, additionally or alternatively,to align the set of building floorplan data with the building outlinedata of the target building, the one or more processors of the tenantbounded server system may be further configured to determine a perimeterratio between a perimeter of the building outline data of the targetbuilding and a perimeter of the set of building floorplan data, andscale the set of building floorplan data based on the perimeter ratio.In this aspect, additionally or alternatively, to align the set ofbuilding floorplan data with the building outline data of the targetbuilding, the one or more processors of the tenant bounded server systemmay be further configured to rotate the set of building floorplan datato minimize a difference in an area between the set of buildingfloorplan data and the building outline data of the target building. Inthis aspect, additionally or alternatively, the set of buildingfloorplan data may include building floorplan data for a plurality offloors. In this aspect, additionally or alternatively, to align the setof building floorplan data with the building outline data of the targetbuilding, the one or more processors of the tenant bounded server systemmay be further configured to determine anchor points between thebuilding floorplan data of the plurality of floors, join the set ofbuilding floorplan data of the plurality of floors based on thedetermined anchor points, and align the joined set of building floorplandata with the building outline data of the target building. In thisaspect, additionally or alternatively, the anchor points may bedetermined based on identifying elevators or stairs in the set ofbuilding floor plan data. In this aspect, additionally or alternatively,to align the set of building floorplan data with the building outlinedata of the target building, the one or more processors of the tenantbounded server system may be further configured to receive an alignmentinput from an authorized user of the tenant entity, and align the set offloorplan outline data with the building outline data of the targetbuilding based on the alignment input. In this aspect, additionally oralternatively, the alignment input may be selected from the groupconsisting of a translation alignment, a scaling alignment, and arotation alignment. In this aspect, additionally or alternatively, aprocessor of the server system may be configured to determine that aclient computer device is authorized to access the set of building floorplan data stored on tenant bounded server system, and send the set ofbuilding floor plan data and at least a portion of the platform map datato the client computer device to cause the client computer device topresent a merged view of the set of building floorplan data and theportion of platform map data.

Another aspect provides a method comprising, at one or more processorsof a platform server system, executing a platform map service configuredto store platform map data that is geospatially referenced and includesbuilding outline data for one or more buildings, and providing theplatform map data to client computer devices. The method furthercomprises, at one or more processors of a tenant bounded server system,storing building floorplan data for a tenant entity, and providing thebuilding floorplan data to client computer devices that areauthenticated for the tenant entity. The method further comprises, atone or more processors of a tenant bounded server system, receiving aset of building floorplan data for a target building included in theplatform map data. The set of building floorplan data is associated withthe tenant entity. The method further comprises determining geospatialreference data for the set of building floorplan data by aligning theset of building floorplan data with building outline data of the targetbuilding, and storing the set of building floorplan data and thedetermined geospatial reference data in a tenant boundary of the tenantentity. In this aspect, additionally or alternatively, aligning the setof building floorplan data with the building outline data of the targetbuilding may further comprise determining a centroid of the buildingoutline data of the target building and a centroid of the set ofbuilding floorplan data, and translating the set of building floorplandata to align the centroid of the set of building floorplan data withthe centroid of the building outline data of the target building. Inthis aspect, additionally or alternatively, aligning the set of buildingfloorplan data with the building outline data of the target building mayfurther comprise determining a perimeter ratio between a perimeter ofthe building outline data of the target building and a perimeter of theset of building floorplan data, and scaling the set of buildingfloorplan data based on the perimeter ratio. In this aspect,additionally or alternatively, aligning the set of building floorplandata with the building outline data of the target building may furthercomprise rotating the set of building floorplan data to minimize adifference in an area between the set of building floorplan data and thebuilding outline data of the target building. In this aspect,additionally or alternatively, the set of building floorplan data mayinclude building floorplan data for a plurality of floors, and aligningthe set of building floorplan data with the building outline data of thetarget building may further comprise determining anchor points betweenthe building floorplan data of the plurality of floors, joining the setof building floorplan data of the plurality of floors based on thedetermined anchor points, and aligning the joined set of buildingfloorplan data with the building outline data of the target building. Inthis aspect, additionally or alternatively, the anchor points may bedetermined based on identifying elevators or stairs in the set ofbuilding floor plan data. In this aspect, additionally or alternatively,aligning the set of building floorplan data with the building outlinedata of the target building may further comprise receiving an alignmentinput from an authorized user of the tenant entity, and aligning the setof floorplan outline data with the building outline data of the targetbuilding based on the alignment input. In this aspect, additionally oralternatively, the alignment input may be selected from the groupconsisting of a translation alignment, a scaling alignment, and arotation alignment. In this aspect, additionally or alternatively, themethod may further comprise determining that a client computer device isauthorized to access the set of building floor plan data stored ontenant bounded server system, and sending the set of building floor plandata and at least a portion of the platform map data to the clientcomputer device to cause the client computer device to present a mergedview of the set of building floorplan data and the portion of platformmap data.

Another aspect provides a server system comprising a platform serversystem including one or more processors configured to execute a platformmap service configured to store platform map data that is geospatiallyreferenced. The server system further comprises a tenant bounded serversystem including one or more processors configured to store geospatiallyreferenced building floorplan data for a tenant entity. The one or moreprocessors of the server system are configured to determine that aclient computer device is authorized to access the geospatiallyreferenced building floor plan data stored on tenant bounded serversystem, and send the set of building floor plan data and at least aportion of the platform map data to the client computer device to causethe client computer device to present a merged view of the set ofbuilding floorplan data and the portion of platform map data.

It will be understood that the configurations and/or approachesdescribed herein are exemplary in nature, and that these specificembodiments or examples are not to be considered in a limiting sense,because numerous variations are possible. The specific routines ormethods described herein may represent one or more of any number ofprocessing strategies. As such, various acts illustrated and/ordescribed may be performed in the sequence illustrated and/or described,in other sequences, in parallel, or omitted. Likewise, the order of theabove-described processes may be changed.

The subject matter of the present disclosure includes all novel andnon-obvious combinations and sub-combinations of the various processes,systems and configurations, and other features, functions, acts, and/orproperties disclosed herein, as well as any and all equivalents thereof.

What is claimed is:
 1. A client computing device comprising: aprocessor; and memory storing instructions that, when executed by theprocessor, cause the processor to perform acts comprising: transmittinga request for an outdoor map to a server computing system that is innetwork communication with the client computing device, wherein theoutdoor map is of a geographic region that includes a building;receiving, from the server computing system, map data based upon therequest for the outdoor map; rendering the map data such that theoutdoor map is displayed on a display of the client computing device;while the outdoor map is displayed on the display, transmitting arequest for floorplan data for the building to the server computingsystem, wherein the request includes authorization data that authorizesa user of the client computing device to receive the floorplan data forthe building; receiving, from the server computing system, the floorplandata for the building, where the floorplan data for the buildingincludes an indoor map of the building and is received by the clientcomputing device due to the request for the floorplan data including theauthorization data; and presenting a merged view of the outdoor map ofthe geographic region and the indoor map of the building on the displayof the client computing device.
 2. The client computing device of claim1, the acts further comprising: receiving, from the server computingsystem, map control logic that, when executed by the processor of theclient computing device, renders the map data upon receipt of the mapdata and renders the merged view upon receipt of the floorplan data. 3.The client computing device of claim 1, where the authorization datacomprises an authorization token that authorizes the user of the clientcomputing device to receive the floorplan data for the building.
 4. Theclient computing device of claim 1, wherein the floorplan authorizationdata comprises login data for an account of the user of the clientcomputing device with an entity associated with the building.
 5. Theclient computing device of claim 1, wherein the map data comprisesbuilding outline data for the building, where the building outline dataidentifies a footprint of the building, and further wherein the mergedview of the outdoor map is presented based upon the building outlinedata.
 6. The client computing device of claim 5, wherein the buildingoutline data includes geospatial reference data that indicates ageographic location of the footprint of the building, and furtherwherein the merged view of the outdoor map is presented based upon thegeospatial reference data assigned to the building outline data.
 7. theclient computing device of claim 6, wherein presenting the merged viewof the outdoor map of the geographic region and the indoor map of thebuilding on the display of the client computing device comprises:aligning second geospatial reference of the building floor plan datawith the geospatial reference data included in the building outlinedata.
 8. The client computing device of claim 1, wherein the merged viewof the outdoor map is presented in a web browser executing on the clientcomputing device.
 9. The client computing device of claim 1, wherein therequest for the outdoor map comprises an address of the building. 10.The client computing device of claim 1, wherein the building floorplandata comprises floorplan layouts of multiple floors of the building. 11.A method performed by a client computing device that is in networkcommunication with a server computing system, the method comprising:transmitting a request for a map to a server computing system, where therequest comprises authorization data that authorizes a user of theclient computing device to access floorplan data for a building of anentity, and further where the request for the map comprises anidentifier of a geographic location that corresponds to the building ofthe entity; receiving, from the server computing system; map data thatthat is available to the general public; and the floorplan data for thebuilding that is received by the client computing device based upon theauthorization data included in the request for the map; and renderingthe map on a display of the client computing device based upon the mapdata and the floorplan data, where the map includes an outdoor map ofthe geographic location that is based upon the map data, where the mapfurther includes an indoor map of the building that is based upon thefloorplan data.
 12. The method of claim 11, wherein the authorizationdata is an authorization token.
 13. The method of claim 11, wherein thefloorplan data for the building of the entity is restricted to users whohave been authorized by the entity.
 14. The method of claim 11, whereinthe map data comprises geospatial reference data that identifies anoutline of the building, and further wherein the map is rendered on thedisplay based upon the geospatial reference data.
 15. The method ofclaim 14, wherein the floorplan data for the building comprises secondgeospatial reference data that identifies geographic locations offeatures of the building, and further wherein the map is rendered on thedisplay based upon the second geospatial reference data.
 16. The methodof claim 11, wherein the floorplan data includes floorplan informationabout multiple floors of the building.
 17. The method of claim 11,further comprising: receiving map control logic from the servercomputing system, where the map control logic renders the map on thedisplay of the client computing device.
 18. A non-transitorycomputer-readable storage medium comprising instructions that, whenexecuted by a processor, cause the processor to perform acts comprising:transmitting a request for a map to a server computing system, where therequest comprises authorization data that authorizes a user of theclient computing device to access floorplan data for a building of anentity, and further where the request for the map comprises anidentifier of a geographic location that corresponds to the building ofthe entity; receiving, from the server computing system; map data thatthat is available to the general public; and the floorplan data for thebuilding that is received by the client computing device based upon theauthorization data included in the request for the map; and renderingthe map on a display of the client computing device based upon the mapdata and the floorplan data, where the map includes an outdoor map ofthe geographic location that is based upon the map data, where the mapfurther includes an indoor map of the building that is based upon thefloorplan data.
 19. The non-transitory computer-readable medium of claim18, wherein the authorization data is an authorization token.
 20. Thenon-transitory computer-readable medium of claim 18, wherein thefloorplan data for the building of the entity is restricted to users whohave been authorized by the entity.